package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;

/**
 * API de persistência de dados da entidade MODELO_HIDROMETRO
 * @author Gerado pelo Telescope
 */
public class EntModeloHidrometro extends Entity {
    
    public final static String ENTITY_NAME = "ZTEST.MODELO_HIDROMETRO";
    public final static String TABLE_NAME = "MODELO_HIDROMETRO";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntModeloHidrometro() {
        super();
        initialize();
    }
    
    public EntModeloHidrometro(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aCodigo = new DomUpper(this,"CODIGO", "Código do modelo de hidrômetro"); 
        aCodigo.setRequired(true);
        aCodigo.setSize(20);
        oCodigo = new DomUpper();
        aDescricao = new DomText(this,"DESCRICAO", "Descrição do hidrômetro"); 
        aDescricao.setRequired(true);
        aDescricao.setSize(128);
        oDescricao = new DomText();
        aDiametroNominal = new DomInteger(this,"DIAMETRO_NOMINAL", "Diâmetro nominal (mm)"); 
        aDiametroNominal.setRequired(true);
        oDiametroNominal = new DomInteger();
        aClasseHorizontalId = new DomId(this,"CLASSE_HORIZONTAL_ID", "Classe metrológica na horizontal"); 
        aClasseHorizontalId.setRequired(true);
        oClasseHorizontalId = new DomId();
        aClasseVerticalId = new DomId(this,"CLASSE_VERTICAL_ID", "Classe metrológica na vertical"); 
        oClasseVerticalId = new DomId();
        aMarca = new DomUpper(this,"MARCA", "Marca"); 
        aMarca.setRequired(true);
        aMarca.setSize(40);
        aMarca.setDefaultValue("ZENNER");
        oMarca = new DomUpper();
        aFatorK = new DomDouble(this,"FATOR_K", "Fator K"); 
        oFatorK = new DomDouble();
        aPortariaAprovacao = new DomText(this,"PORTARIA_APROVACAO", "Portaria de aprovação"); 
        oPortariaAprovacao = new DomText();
        aComprimento = new DomInteger(this,"COMPRIMENTO", "Comprimento (mm)"); 
        aComprimento.setRequired(true);
        oComprimento = new DomInteger();
        aVazaoPrefixoSerieId = new DomId(this,"VAZAO_PREFIXO_SERIE_ID", "Vazão do hidrômetro"); 
        aVazaoPrefixoSerieId.setRequired(true);
        oVazaoPrefixoSerieId = new DomId();
        aDescricaoDetalhada = new DomTextLong(this,"DESCRICAO_DETALHADA", "Descrição detalhada do modelo"); 
        aDescricaoDetalhada.setSize(8192);
        oDescricaoDetalhada = new DomTextLong();
        aRazaoHorizontalId = new DomId(this,"RAZAO_HORIZONTAL_ID", "Razão da vazão horizontal"); 
        oRazaoHorizontalId = new DomId();
        aRazaoVerticalId = new DomId(this,"RAZAO_VERTICAL_ID", "Razão da vazão vertical"); 
        oRazaoVerticalId = new DomId();
        aVazaoPermanenteId = new DomId(this,"VAZAO_PERMANENTE_ID", "Vazão permanente"); 
        aVazaoPermanenteId.setRequired(true);
        oVazaoPermanenteId = new DomId();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Código do modelo de hidrômetro
    private DomUpper aCodigo;
    private DomUpper oCodigo;
    
    // Descrição do hidrômetro
    private DomText aDescricao;
    private DomText oDescricao;
    
    // Diâmetro nominal (mm)
    private DomInteger aDiametroNominal;
    private DomInteger oDiametroNominal;
    
    // Classe metrológica na horizontal
    private DomId aClasseHorizontalId;
    private DomId oClasseHorizontalId;
    
    // Classe metrológica na vertical
    private DomId aClasseVerticalId;
    private DomId oClasseVerticalId;
    
    // Marca
    private DomUpper aMarca;
    private DomUpper oMarca;
    
    // Fator K
    private DomDouble aFatorK;
    private DomDouble oFatorK;
    
    // Portaria de aprovação
    private DomText aPortariaAprovacao;
    private DomText oPortariaAprovacao;
    
    // Comprimento (mm)
    private DomInteger aComprimento;
    private DomInteger oComprimento;
    
    // Vazão do hidrômetro
    private DomId aVazaoPrefixoSerieId;
    private DomId oVazaoPrefixoSerieId;
    
    // Descrição detalhada do modelo
    private DomTextLong aDescricaoDetalhada;
    private DomTextLong oDescricaoDetalhada;
    
    // Razão da vazão horizontal
    private DomId aRazaoHorizontalId;
    private DomId oRazaoHorizontalId;
    
    // Razão da vazão vertical
    private DomId aRazaoVerticalId;
    private DomId oRazaoVerticalId;
    
    // Vazão permanente
    private DomId aVazaoPermanenteId;
    private DomId oVazaoPermanenteId;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntModeloHidrometro id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo CODIGO">
    
    public EntModeloHidrometro codigo(String value) {
        setCodigo(value);
        return this;
    }
    
    public void setCodigo(DomUpper value) {
        if (value == null || value.isNull()) {
            nullifyCodigo();
        } else {
            aCodigo.setValue(value.getValue());
            if (aCodigo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCodigo(String value) {
        if (value == null) {
            nullifyCodigo();
        } else {
            aCodigo.setValue(value);
            if (aCodigo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCodigo(Object value) {
        aCodigo.setValue(value);
        if (aCodigo.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyCodigo() {
        if (!aCodigo.isNull()) {
            aCodigo.setNull(true);
            setModified(true);
        }
    }
    
    public DomUpper getCodigo() {
        return aCodigo;
    }
    
    public DomUpper oldCodigo() {
        return oCodigo;
    }
    
    public String valueOfCodigo() {
        return aCodigo.getValue();
    }
    
    public boolean isCodigoModified() {
        return aCodigo.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo DESCRICAO">
    
    public EntModeloHidrometro descricao(String value) {
        setDescricao(value);
        return this;
    }
    
    public void setDescricao(DomText value) {
        if (value == null || value.isNull()) {
            nullifyDescricao();
        } else {
            aDescricao.setValue(value.getValue());
            if (aDescricao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDescricao(String value) {
        if (value == null) {
            nullifyDescricao();
        } else {
            aDescricao.setValue(value);
            if (aDescricao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDescricao(Object value) {
        aDescricao.setValue(value);
        if (aDescricao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyDescricao() {
        if (!aDescricao.isNull()) {
            aDescricao.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getDescricao() {
        return aDescricao;
    }
    
    public DomText oldDescricao() {
        return oDescricao;
    }
    
    public String valueOfDescricao() {
        return aDescricao.getValue();
    }
    
    public boolean isDescricaoModified() {
        return aDescricao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo DIAMETRO_NOMINAL">
    
    public EntModeloHidrometro diametroNominal(Integer value) {
        setDiametroNominal(value);
        return this;
    }
    
    public void setDiametroNominal(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifyDiametroNominal();
        } else {
            aDiametroNominal.setValue(value.getValue());
            if (aDiametroNominal.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDiametroNominal(String value) {
        if (value == null) {
            nullifyDiametroNominal();
        } else {
            aDiametroNominal.setValue(value);
            if (aDiametroNominal.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDiametroNominal(Integer value) {
        aDiametroNominal.setValue(value);
        if (aDiametroNominal.isModified()) {
            setModified(true);
        }
    }
    
    public void setDiametroNominal(Object value) {
        aDiametroNominal.setValue(value);
        if (aDiametroNominal.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyDiametroNominal() {
        if (!aDiametroNominal.isNull()) {
            aDiametroNominal.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getDiametroNominal() {
        return aDiametroNominal;
    }
    
    public DomInteger oldDiametroNominal() {
        return oDiametroNominal;
    }
    
    public Integer valueOfDiametroNominal() {
        return aDiametroNominal.getValue();
    }
    
    public boolean isDiametroNominalModified() {
        return aDiametroNominal.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo CLASSE_HORIZONTAL_ID">
    
    public EntModeloHidrometro classeHorizontalId(Long value) {
        setClasseHorizontalId(value);
        return this;
    }
    
    public void setClasseHorizontalId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyClasseHorizontalId();
        } else {
            aClasseHorizontalId.setValue(value.getValue());
            if (aClasseHorizontalId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setClasseHorizontalId(String value) {
        if (value == null) {
            nullifyClasseHorizontalId();
        } else {
            aClasseHorizontalId.setValue(value);
            if (aClasseHorizontalId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setClasseHorizontalId(Long value) {
        aClasseHorizontalId.setValue(value);
        if (aClasseHorizontalId.isModified()) {
            setModified(true);
        }
    }
    
    public void setClasseHorizontalId(Object value) {
        aClasseHorizontalId.setValue(value);
        if (aClasseHorizontalId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyClasseHorizontalId() {
        if (!aClasseHorizontalId.isNull()) {
            aClasseHorizontalId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getClasseHorizontalId() {
        return aClasseHorizontalId;
    }
    
    public DomId oldClasseHorizontalId() {
        return oClasseHorizontalId;
    }
    
    public Long valueOfClasseHorizontalId() {
        return aClasseHorizontalId.getValue();
    }
    
    public boolean isClasseHorizontalIdModified() {
        return aClasseHorizontalId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo CLASSE_VERTICAL_ID">
    
    public EntModeloHidrometro classeVerticalId(Long value) {
        setClasseVerticalId(value);
        return this;
    }
    
    public void setClasseVerticalId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyClasseVerticalId();
        } else {
            aClasseVerticalId.setValue(value.getValue());
            if (aClasseVerticalId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setClasseVerticalId(String value) {
        if (value == null) {
            nullifyClasseVerticalId();
        } else {
            aClasseVerticalId.setValue(value);
            if (aClasseVerticalId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setClasseVerticalId(Long value) {
        aClasseVerticalId.setValue(value);
        if (aClasseVerticalId.isModified()) {
            setModified(true);
        }
    }
    
    public void setClasseVerticalId(Object value) {
        aClasseVerticalId.setValue(value);
        if (aClasseVerticalId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyClasseVerticalId() {
        if (!aClasseVerticalId.isNull()) {
            aClasseVerticalId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getClasseVerticalId() {
        return aClasseVerticalId;
    }
    
    public DomId oldClasseVerticalId() {
        return oClasseVerticalId;
    }
    
    public Long valueOfClasseVerticalId() {
        return aClasseVerticalId.getValue();
    }
    
    public boolean isClasseVerticalIdModified() {
        return aClasseVerticalId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo MARCA">
    
    public EntModeloHidrometro marca(String value) {
        setMarca(value);
        return this;
    }
    
    public void setMarca(DomUpper value) {
        if (value == null || value.isNull()) {
            nullifyMarca();
        } else {
            aMarca.setValue(value.getValue());
            if (aMarca.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setMarca(String value) {
        if (value == null) {
            nullifyMarca();
        } else {
            aMarca.setValue(value);
            if (aMarca.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setMarca(Object value) {
        aMarca.setValue(value);
        if (aMarca.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyMarca() {
        if (!aMarca.isNull()) {
            aMarca.setNull(true);
            setModified(true);
        }
    }
    
    public DomUpper getMarca() {
        return aMarca;
    }
    
    public DomUpper oldMarca() {
        return oMarca;
    }
    
    public String valueOfMarca() {
        return aMarca.getValue();
    }
    
    public boolean isMarcaModified() {
        return aMarca.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo FATOR_K">
    
    public EntModeloHidrometro fatorK(Double value) {
        setFatorK(value);
        return this;
    }
    
    public void setFatorK(DomDouble value) {
        if (value == null || value.isNull()) {
            nullifyFatorK();
        } else {
            aFatorK.setValue(value.getValue());
            if (aFatorK.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setFatorK(String value) {
        if (value == null) {
            nullifyFatorK();
        } else {
            aFatorK.setValue(value);
            if (aFatorK.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setFatorK(Double value) {
        aFatorK.setValue(value);
        if (aFatorK.isModified()) {
            setModified(true);
        }
    }
    
    public void setFatorK(Object value) {
        aFatorK.setValue(value);
        if (aFatorK.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyFatorK() {
        if (!aFatorK.isNull()) {
            aFatorK.setNull(true);
            setModified(true);
        }
    }
    
    public DomDouble getFatorK() {
        return aFatorK;
    }
    
    public DomDouble oldFatorK() {
        return oFatorK;
    }
    
    public Double valueOfFatorK() {
        return aFatorK.getValue();
    }
    
    public boolean isFatorKModified() {
        return aFatorK.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo PORTARIA_APROVACAO">
    
    public EntModeloHidrometro portariaAprovacao(String value) {
        setPortariaAprovacao(value);
        return this;
    }
    
    public void setPortariaAprovacao(DomText value) {
        if (value == null || value.isNull()) {
            nullifyPortariaAprovacao();
        } else {
            aPortariaAprovacao.setValue(value.getValue());
            if (aPortariaAprovacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPortariaAprovacao(String value) {
        if (value == null) {
            nullifyPortariaAprovacao();
        } else {
            aPortariaAprovacao.setValue(value);
            if (aPortariaAprovacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPortariaAprovacao(Object value) {
        aPortariaAprovacao.setValue(value);
        if (aPortariaAprovacao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyPortariaAprovacao() {
        if (!aPortariaAprovacao.isNull()) {
            aPortariaAprovacao.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getPortariaAprovacao() {
        return aPortariaAprovacao;
    }
    
    public DomText oldPortariaAprovacao() {
        return oPortariaAprovacao;
    }
    
    public String valueOfPortariaAprovacao() {
        return aPortariaAprovacao.getValue();
    }
    
    public boolean isPortariaAprovacaoModified() {
        return aPortariaAprovacao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo COMPRIMENTO">
    
    public EntModeloHidrometro comprimento(Integer value) {
        setComprimento(value);
        return this;
    }
    
    public void setComprimento(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifyComprimento();
        } else {
            aComprimento.setValue(value.getValue());
            if (aComprimento.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setComprimento(String value) {
        if (value == null) {
            nullifyComprimento();
        } else {
            aComprimento.setValue(value);
            if (aComprimento.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setComprimento(Integer value) {
        aComprimento.setValue(value);
        if (aComprimento.isModified()) {
            setModified(true);
        }
    }
    
    public void setComprimento(Object value) {
        aComprimento.setValue(value);
        if (aComprimento.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyComprimento() {
        if (!aComprimento.isNull()) {
            aComprimento.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getComprimento() {
        return aComprimento;
    }
    
    public DomInteger oldComprimento() {
        return oComprimento;
    }
    
    public Integer valueOfComprimento() {
        return aComprimento.getValue();
    }
    
    public boolean isComprimentoModified() {
        return aComprimento.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo VAZAO_PREFIXO_SERIE_ID">
    
    public EntModeloHidrometro vazaoPrefixoSerieId(Long value) {
        setVazaoPrefixoSerieId(value);
        return this;
    }
    
    public void setVazaoPrefixoSerieId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyVazaoPrefixoSerieId();
        } else {
            aVazaoPrefixoSerieId.setValue(value.getValue());
            if (aVazaoPrefixoSerieId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setVazaoPrefixoSerieId(String value) {
        if (value == null) {
            nullifyVazaoPrefixoSerieId();
        } else {
            aVazaoPrefixoSerieId.setValue(value);
            if (aVazaoPrefixoSerieId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setVazaoPrefixoSerieId(Long value) {
        aVazaoPrefixoSerieId.setValue(value);
        if (aVazaoPrefixoSerieId.isModified()) {
            setModified(true);
        }
    }
    
    public void setVazaoPrefixoSerieId(Object value) {
        aVazaoPrefixoSerieId.setValue(value);
        if (aVazaoPrefixoSerieId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyVazaoPrefixoSerieId() {
        if (!aVazaoPrefixoSerieId.isNull()) {
            aVazaoPrefixoSerieId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getVazaoPrefixoSerieId() {
        return aVazaoPrefixoSerieId;
    }
    
    public DomId oldVazaoPrefixoSerieId() {
        return oVazaoPrefixoSerieId;
    }
    
    public Long valueOfVazaoPrefixoSerieId() {
        return aVazaoPrefixoSerieId.getValue();
    }
    
    public boolean isVazaoPrefixoSerieIdModified() {
        return aVazaoPrefixoSerieId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo DESCRICAO_DETALHADA">
    
    public EntModeloHidrometro descricaoDetalhada(String value) {
        setDescricaoDetalhada(value);
        return this;
    }
    
    public void setDescricaoDetalhada(DomTextLong value) {
        if (value == null || value.isNull()) {
            nullifyDescricaoDetalhada();
        } else {
            aDescricaoDetalhada.setValue(value.getValue());
            if (aDescricaoDetalhada.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDescricaoDetalhada(String value) {
        if (value == null) {
            nullifyDescricaoDetalhada();
        } else {
            aDescricaoDetalhada.setValue(value);
            if (aDescricaoDetalhada.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDescricaoDetalhada(Object value) {
        aDescricaoDetalhada.setValue(value);
        if (aDescricaoDetalhada.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyDescricaoDetalhada() {
        if (!aDescricaoDetalhada.isNull()) {
            aDescricaoDetalhada.setNull(true);
            setModified(true);
        }
    }
    
    public DomTextLong getDescricaoDetalhada() {
        return aDescricaoDetalhada;
    }
    
    public DomTextLong oldDescricaoDetalhada() {
        return oDescricaoDetalhada;
    }
    
    public String valueOfDescricaoDetalhada() {
        return aDescricaoDetalhada.getValue();
    }
    
    public boolean isDescricaoDetalhadaModified() {
        return aDescricaoDetalhada.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo RAZAO_HORIZONTAL_ID">
    
    public EntModeloHidrometro razaoHorizontalId(Long value) {
        setRazaoHorizontalId(value);
        return this;
    }
    
    public void setRazaoHorizontalId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyRazaoHorizontalId();
        } else {
            aRazaoHorizontalId.setValue(value.getValue());
            if (aRazaoHorizontalId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setRazaoHorizontalId(String value) {
        if (value == null) {
            nullifyRazaoHorizontalId();
        } else {
            aRazaoHorizontalId.setValue(value);
            if (aRazaoHorizontalId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setRazaoHorizontalId(Long value) {
        aRazaoHorizontalId.setValue(value);
        if (aRazaoHorizontalId.isModified()) {
            setModified(true);
        }
    }
    
    public void setRazaoHorizontalId(Object value) {
        aRazaoHorizontalId.setValue(value);
        if (aRazaoHorizontalId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyRazaoHorizontalId() {
        if (!aRazaoHorizontalId.isNull()) {
            aRazaoHorizontalId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getRazaoHorizontalId() {
        return aRazaoHorizontalId;
    }
    
    public DomId oldRazaoHorizontalId() {
        return oRazaoHorizontalId;
    }
    
    public Long valueOfRazaoHorizontalId() {
        return aRazaoHorizontalId.getValue();
    }
    
    public boolean isRazaoHorizontalIdModified() {
        return aRazaoHorizontalId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo RAZAO_VERTICAL_ID">
    
    public EntModeloHidrometro razaoVerticalId(Long value) {
        setRazaoVerticalId(value);
        return this;
    }
    
    public void setRazaoVerticalId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyRazaoVerticalId();
        } else {
            aRazaoVerticalId.setValue(value.getValue());
            if (aRazaoVerticalId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setRazaoVerticalId(String value) {
        if (value == null) {
            nullifyRazaoVerticalId();
        } else {
            aRazaoVerticalId.setValue(value);
            if (aRazaoVerticalId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setRazaoVerticalId(Long value) {
        aRazaoVerticalId.setValue(value);
        if (aRazaoVerticalId.isModified()) {
            setModified(true);
        }
    }
    
    public void setRazaoVerticalId(Object value) {
        aRazaoVerticalId.setValue(value);
        if (aRazaoVerticalId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyRazaoVerticalId() {
        if (!aRazaoVerticalId.isNull()) {
            aRazaoVerticalId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getRazaoVerticalId() {
        return aRazaoVerticalId;
    }
    
    public DomId oldRazaoVerticalId() {
        return oRazaoVerticalId;
    }
    
    public Long valueOfRazaoVerticalId() {
        return aRazaoVerticalId.getValue();
    }
    
    public boolean isRazaoVerticalIdModified() {
        return aRazaoVerticalId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo VAZAO_PERMANENTE_ID">
    
    public EntModeloHidrometro vazaoPermanenteId(Long value) {
        setVazaoPermanenteId(value);
        return this;
    }
    
    public void setVazaoPermanenteId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyVazaoPermanenteId();
        } else {
            aVazaoPermanenteId.setValue(value.getValue());
            if (aVazaoPermanenteId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setVazaoPermanenteId(String value) {
        if (value == null) {
            nullifyVazaoPermanenteId();
        } else {
            aVazaoPermanenteId.setValue(value);
            if (aVazaoPermanenteId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setVazaoPermanenteId(Long value) {
        aVazaoPermanenteId.setValue(value);
        if (aVazaoPermanenteId.isModified()) {
            setModified(true);
        }
    }
    
    public void setVazaoPermanenteId(Object value) {
        aVazaoPermanenteId.setValue(value);
        if (aVazaoPermanenteId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyVazaoPermanenteId() {
        if (!aVazaoPermanenteId.isNull()) {
            aVazaoPermanenteId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getVazaoPermanenteId() {
        return aVazaoPermanenteId;
    }
    
    public DomId oldVazaoPermanenteId() {
        return oVazaoPermanenteId;
    }
    
    public Long valueOfVazaoPermanenteId() {
        return aVazaoPermanenteId.getValue();
    }
    
    public boolean isVazaoPermanenteIdModified() {
        return aVazaoPermanenteId.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    @Override
    protected void processDeleteRestrict() throws AdsException {
        // Nullify cascade ZTEST.ENSAIO_BANCADA.FK_ENBANC_MODELO_HIDROMETRO
        {
            EntEnsaioBancada external = new EntEnsaioBancada(ctx);
            external.findByModeloHidrometro(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.ENSAIO_BANCADA.FK_ENBANC_MODELO_HIDROMETRO.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Ensaios nas bancadas fazendo referencia para este registro");
            }
            external.close();
        }
        // Nullify cascade ZTEST.MODELO_ENSAIO_INTRUMENTO.FK_MENAIN_MODELO_HIDROMETRO
        {
            EntModeloEnsaioIntrumento external = new EntModeloEnsaioIntrumento(ctx);
            external.findByModeloHidrometro(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.MODELO_ENSAIO_INTRUMENTO.FK_MENAIN_MODELO_HIDROMETRO.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Modelos para ensaios nos instrumentos de ensaios fazendo referencia para este registro");
            }
            external.close();
        }
        // Nullify cascade ZTEST.SOLICITACAO_ENSAIO.FK_SOLENS_MODELO_HIDROMETRO
        {
            EntSolicitacaoEnsaio external = new EntSolicitacaoEnsaio(ctx);
            external.findByModeloHidrometro(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.SOLICITACAO_ENSAIO.FK_SOLENS_MODELO_HIDROMETRO.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Solicitações de ensaios fazendo referencia para este registro");
            }
            external.close();
        }
    }
    
    @Override
    protected void processDeleteCascade() throws AdsException {
        // Delete cascade ZTEST.HIDROMETRO.FK_HIDRMT_MODELO_HIDROMETRO
        {
            EntHidrometro hidrometro = new EntHidrometro(ctx);
            hidrometro.del("select id from HIDROMETRO where MODELO_HIDROMETRO_ID = " + valueOfId());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            if (msg.indexOf("FK_ENBANC_MODELO_HIDROMETRO") >= 0) {
                e = new AdsException("ZTEST.ENSAIO_BANCADA.FK_ENBANC_MODELO_HIDROMETRO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Ensaios nas bancadas fazendo referencia para este registro! (FK_ENBANC_MODELO_HIDROMETRO)");
                return e;
            } else if (msg.indexOf("FK_MENAIN_MODELO_HIDROMETRO") >= 0) {
                e = new AdsException("ZTEST.MODELO_ENSAIO_INTRUMENTO.FK_MENAIN_MODELO_HIDROMETRO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Modelos para ensaios nos instrumentos de ensaios fazendo referencia para este registro! (FK_MENAIN_MODELO_HIDROMETRO)");
                return e;
            } else if (msg.indexOf("FK_SOLENS_MODELO_HIDROMETRO") >= 0) {
                e = new AdsException("ZTEST.SOLICITACAO_ENSAIO.FK_SOLENS_MODELO_HIDROMETRO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Solicitações de ensaios fazendo referencia para este registro! (FK_SOLENS_MODELO_HIDROMETRO)");
                return e;
            } else {
                e = new AdsException("ZTEST.MODELO_HIDROMETRO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        } else {
            if (msg.indexOf("PREFIXOS_IGUAIS_VAZOES_INFORMADAS") >= 0) {
                e = new AdsException("ZTEST.MODELO_HIDROMETRO.PREFIXOS_IGUAIS_VAZOES_INFORMADAS", 
                        Severity.ERROR,
                        "Regra inválida! Prefixos das vazões informadas devem ser iguais! (PREFIXOS_IGUAIS_VAZOES_INFORMADAS)");
                return e;
            } else if (msg.indexOf("FK_MODHID_VAZAO_PERMANENTE") >= 0) {
                e = new AdsException("ZTEST.MODELO_HIDROMETRO.FK_MODHID_VAZAO_PERMANENTE", 
                        Severity.ERROR,
                        "Registro não cadastrado para VAZAO_PERMANENTE! (FK_MODHID_VAZAO_PERMANENTE)");
                return e;
            } else if (msg.indexOf("FK_MODHID_RAZAO_VERTICAL") >= 0) {
                e = new AdsException("ZTEST.MODELO_HIDROMETRO.FK_MODHID_RAZAO_VERTICAL", 
                        Severity.ERROR,
                        "Registro não cadastrado para RAZAO_VERTICAL! (FK_MODHID_RAZAO_VERTICAL)");
                return e;
            } else if (msg.indexOf("FK_MODHID_RAZAO_HORIZONTAL") >= 0) {
                e = new AdsException("ZTEST.MODELO_HIDROMETRO.FK_MODHID_RAZAO_HORIZONTAL", 
                        Severity.ERROR,
                        "Registro não cadastrado para RAZAO_HORIZONTAL! (FK_MODHID_RAZAO_HORIZONTAL)");
                return e;
            } else if (msg.indexOf("FK_MODHID_VAZAO_HIDROMETRO") >= 0) {
                e = new AdsException("ZTEST.MODELO_HIDROMETRO.FK_MODHID_VAZAO_HIDROMETRO", 
                        Severity.ERROR,
                        "Registro não cadastrado para VAZAO_PREFIXO_SERIE! (FK_MODHID_VAZAO_HIDROMETRO)");
                return e;
            } else if (msg.indexOf("UK_MODHID_COD_DIAM_VAZAO") >= 0) {
                e = new AdsException("ZTEST.MODELO_HIDROMETRO.UK_MODHID_COD_DIAM_VAZAO", 
                        Severity.ERROR,
                        "Registro duplicado! Código do modelo de hidrômetro, diâmetro e vazão do tipo deste modelo devem ser únicos. Código do modelo de hidrômetro ${CODIGO}, Diâmetro nominal (mm) ${DIAMETRO_NOMINAL}, Vazão do hidrômetro ${VAZAO_PREFIXO_SERIE_ID} (UK_MODHID_COD_DIAM_VAZAO)");
                return e;
            } else if (msg.indexOf("VERIFICAR_CLASSES_VERTICAL_HORIZONTAL") >= 0) {
                e = new AdsException("ZTEST.MODELO_HIDROMETRO.VERIFICAR_CLASSES_VERTICAL_HORIZONTAL", 
                        Severity.ERROR,
                        "Regra inválida! O modelo deve ter classes vertical ou horizontal (ou ambas) registradas! (VERIFICAR_CLASSES_VERTICAL_HORIZONTAL)");
                return e;
            } else if (msg.indexOf("FK_MODHID_CLASSE_VERTICAL") >= 0) {
                e = new AdsException("ZTEST.MODELO_HIDROMETRO.FK_MODHID_CLASSE_VERTICAL", 
                        Severity.ERROR,
                        "Registro não cadastrado para CLASSE_VERTICAL! (FK_MODHID_CLASSE_VERTICAL)");
                return e;
            } else if (msg.indexOf("FK_MODHID_CLASSE_HORIZONTAL") >= 0) {
                e = new AdsException("ZTEST.MODELO_HIDROMETRO.FK_MODHID_CLASSE_HORIZONTAL", 
                        Severity.ERROR,
                        "Registro não cadastrado para CLASSE_HORIZONTAL! (FK_MODHID_CLASSE_HORIZONTAL)");
                return e;
            } else if (msg.indexOf("UK_MODHID_NOME") >= 0) {
                e = new AdsException("ZTEST.MODELO_HIDROMETRO.UK_MODHID_NOME", 
                        Severity.ERROR,
                        "Registro duplicado! Código do modelo de hidrômetro deve ser único. Descrição do hidrômetro ${DESCRICAO} (UK_MODHID_NOME)");
                return e;
            } else if (msg.indexOf("PK_MODHID") >= 0) {
                e = new AdsException("ZTEST.MODELO_HIDROMETRO.PK_MODHID", 
                        Severity.ERROR,
                        "ID duplicado! (PK_MODHID)");
                return e;
            } else {
                e = new AdsException("ZTEST.MODELO_HIDROMETRO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aCodigo);
            allAttributes.add(aDescricao);
            allAttributes.add(aDiametroNominal);
            allAttributes.add(aClasseHorizontalId);
            allAttributes.add(aClasseVerticalId);
            allAttributes.add(aMarca);
            allAttributes.add(aFatorK);
            allAttributes.add(aPortariaAprovacao);
            allAttributes.add(aComprimento);
            allAttributes.add(aVazaoPrefixoSerieId);
            allAttributes.add(aDescricaoDetalhada);
            allAttributes.add(aRazaoHorizontalId);
            allAttributes.add(aRazaoVerticalId);
            allAttributes.add(aVazaoPermanenteId);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getCodigo().toString() +
                " " + getDiametroNominal().toString() +
                " " + getVazaoPrefixoSerieId().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    
    public void findByCodigoDiametroNominalVazaoPrefixoSerieId(String codigo, int diametroNominal, long vazaoPrefixoSerieId) throws AdsException {
        findBy(new String[] {"CODIGO", "DIAMETRO_NOMINAL", "VAZAO_PREFIXO_SERIE_ID"},
                new Object[] {codigo, diametroNominal, vazaoPrefixoSerieId});
    }
    
    public void findByDescricao(String descricao) throws AdsException {
        findBy(new String[] {"DESCRICAO"},
                new Object[] {descricao});
    }
    
    private EntVazaoPrefixoSerie eVazaoPermanente;
    
    public EntVazaoPrefixoSerie findVazaoPermanente() throws AdsException {
        if (getVazaoPermanenteId().isNull()) {
            return null;
        }
        if (eVazaoPermanente == null || !valueOfVazaoPermanenteId().equals(eVazaoPermanente.valueOfId())) {
            eVazaoPermanente = new EntVazaoPrefixoSerie(ctx);
            eVazaoPermanente.find(valueOfVazaoPermanenteId());
        }
        return eVazaoPermanente;
    }
    
    /**
     * Ativa o join desta entidade com VAZAO_PREFIXO_SERIE
     * através do atributo VAZAO_PERMANENTE_ID
     */
    public EntVazaoPrefixoSerie joinVazaoPermanente() {
        return joinVazaoPermanente(null);
    }
    public EntVazaoPrefixoSerie joinVazaoPermanente(String alias) {
        EntVazaoPrefixoSerie entity = new EntVazaoPrefixoSerie(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getVazaoPermanenteId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByVazaoPermanente(long id, String sqlAppend) throws AdsException {
        find("select ID from MODELO_HIDROMETRO where VAZAO_PERMANENTE_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByVazaoPermanente(long id) throws AdsException {
        findByVazaoPermanente(id,"");
    }
    
    public void findByVazaoPermanente(Entity entidade) throws AdsException {
        findByVazaoPermanente(entidade.valueOfId(),"");
    }
    
    public void findByVazaoPermanente(Entity entidade, String sqlAppend) throws AdsException {
        findByVazaoPermanente(entidade.valueOfId(),sqlAppend);
    }
    
    private EntClasseModelo eRazaoVertical;
    
    public EntClasseModelo findRazaoVertical() throws AdsException {
        if (getRazaoVerticalId().isNull()) {
            return null;
        }
        if (eRazaoVertical == null || !valueOfRazaoVerticalId().equals(eRazaoVertical.valueOfId())) {
            eRazaoVertical = new EntClasseModelo(ctx);
            eRazaoVertical.find(valueOfRazaoVerticalId());
        }
        return eRazaoVertical;
    }
    
    /**
     * Ativa o join desta entidade com CLASSE_MODELO
     * através do atributo RAZAO_VERTICAL_ID
     */
    public EntClasseModelo joinRazaoVertical() {
        return joinRazaoVertical(null);
    }
    public EntClasseModelo joinRazaoVertical(String alias) {
        EntClasseModelo entity = new EntClasseModelo(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getRazaoVerticalId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByRazaoVertical(long id, String sqlAppend) throws AdsException {
        find("select ID from MODELO_HIDROMETRO where RAZAO_VERTICAL_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByRazaoVertical(long id) throws AdsException {
        findByRazaoVertical(id,"");
    }
    
    public void findByRazaoVertical(Entity entidade) throws AdsException {
        findByRazaoVertical(entidade.valueOfId(),"");
    }
    
    public void findByRazaoVertical(Entity entidade, String sqlAppend) throws AdsException {
        findByRazaoVertical(entidade.valueOfId(),sqlAppend);
    }
    
    private EntClasseModelo eRazaoHorizontal;
    
    public EntClasseModelo findRazaoHorizontal() throws AdsException {
        if (getRazaoHorizontalId().isNull()) {
            return null;
        }
        if (eRazaoHorizontal == null || !valueOfRazaoHorizontalId().equals(eRazaoHorizontal.valueOfId())) {
            eRazaoHorizontal = new EntClasseModelo(ctx);
            eRazaoHorizontal.find(valueOfRazaoHorizontalId());
        }
        return eRazaoHorizontal;
    }
    
    /**
     * Ativa o join desta entidade com CLASSE_MODELO
     * através do atributo RAZAO_HORIZONTAL_ID
     */
    public EntClasseModelo joinRazaoHorizontal() {
        return joinRazaoHorizontal(null);
    }
    public EntClasseModelo joinRazaoHorizontal(String alias) {
        EntClasseModelo entity = new EntClasseModelo(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getRazaoHorizontalId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByRazaoHorizontal(long id, String sqlAppend) throws AdsException {
        find("select ID from MODELO_HIDROMETRO where RAZAO_HORIZONTAL_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByRazaoHorizontal(long id) throws AdsException {
        findByRazaoHorizontal(id,"");
    }
    
    public void findByRazaoHorizontal(Entity entidade) throws AdsException {
        findByRazaoHorizontal(entidade.valueOfId(),"");
    }
    
    public void findByRazaoHorizontal(Entity entidade, String sqlAppend) throws AdsException {
        findByRazaoHorizontal(entidade.valueOfId(),sqlAppend);
    }
    
    private EntVazaoPrefixoSerie eVazaoPrefixoSerie;
    
    public EntVazaoPrefixoSerie findVazaoPrefixoSerie() throws AdsException {
        if (getVazaoPrefixoSerieId().isNull()) {
            return null;
        }
        if (eVazaoPrefixoSerie == null || !valueOfVazaoPrefixoSerieId().equals(eVazaoPrefixoSerie.valueOfId())) {
            eVazaoPrefixoSerie = new EntVazaoPrefixoSerie(ctx);
            eVazaoPrefixoSerie.find(valueOfVazaoPrefixoSerieId());
        }
        return eVazaoPrefixoSerie;
    }
    
    /**
     * Ativa o join desta entidade com VAZAO_PREFIXO_SERIE
     * através do atributo VAZAO_PREFIXO_SERIE_ID
     */
    public EntVazaoPrefixoSerie joinVazaoPrefixoSerie() {
        return joinVazaoPrefixoSerie(null);
    }
    public EntVazaoPrefixoSerie joinVazaoPrefixoSerie(String alias) {
        EntVazaoPrefixoSerie entity = new EntVazaoPrefixoSerie(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getVazaoPrefixoSerieId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByVazaoPrefixoSerie(long id, String sqlAppend) throws AdsException {
        find("select ID from MODELO_HIDROMETRO where VAZAO_PREFIXO_SERIE_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByVazaoPrefixoSerie(long id) throws AdsException {
        findByVazaoPrefixoSerie(id,"");
    }
    
    public void findByVazaoPrefixoSerie(Entity entidade) throws AdsException {
        findByVazaoPrefixoSerie(entidade.valueOfId(),"");
    }
    
    public void findByVazaoPrefixoSerie(Entity entidade, String sqlAppend) throws AdsException {
        findByVazaoPrefixoSerie(entidade.valueOfId(),sqlAppend);
    }
    
    private EntClasseModelo eClasseVertical;
    
    public EntClasseModelo findClasseVertical() throws AdsException {
        if (getClasseVerticalId().isNull()) {
            return null;
        }
        if (eClasseVertical == null || !valueOfClasseVerticalId().equals(eClasseVertical.valueOfId())) {
            eClasseVertical = new EntClasseModelo(ctx);
            eClasseVertical.find(valueOfClasseVerticalId());
        }
        return eClasseVertical;
    }
    
    /**
     * Ativa o join desta entidade com CLASSE_MODELO
     * através do atributo CLASSE_VERTICAL_ID
     */
    public EntClasseModelo joinClasseVertical() {
        return joinClasseVertical(null);
    }
    public EntClasseModelo joinClasseVertical(String alias) {
        EntClasseModelo entity = new EntClasseModelo(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getClasseVerticalId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByClasseVertical(long id, String sqlAppend) throws AdsException {
        find("select ID from MODELO_HIDROMETRO where CLASSE_VERTICAL_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByClasseVertical(long id) throws AdsException {
        findByClasseVertical(id,"");
    }
    
    public void findByClasseVertical(Entity entidade) throws AdsException {
        findByClasseVertical(entidade.valueOfId(),"");
    }
    
    public void findByClasseVertical(Entity entidade, String sqlAppend) throws AdsException {
        findByClasseVertical(entidade.valueOfId(),sqlAppend);
    }
    
    private EntClasseModelo eClasseHorizontal;
    
    public EntClasseModelo findClasseHorizontal() throws AdsException {
        if (getClasseHorizontalId().isNull()) {
            return null;
        }
        if (eClasseHorizontal == null || !valueOfClasseHorizontalId().equals(eClasseHorizontal.valueOfId())) {
            eClasseHorizontal = new EntClasseModelo(ctx);
            eClasseHorizontal.find(valueOfClasseHorizontalId());
        }
        return eClasseHorizontal;
    }
    
    /**
     * Ativa o join desta entidade com CLASSE_MODELO
     * através do atributo CLASSE_HORIZONTAL_ID
     */
    public EntClasseModelo joinClasseHorizontal() {
        return joinClasseHorizontal(null);
    }
    public EntClasseModelo joinClasseHorizontal(String alias) {
        EntClasseModelo entity = new EntClasseModelo(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getClasseHorizontalId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByClasseHorizontal(long id, String sqlAppend) throws AdsException {
        find("select ID from MODELO_HIDROMETRO where CLASSE_HORIZONTAL_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByClasseHorizontal(long id) throws AdsException {
        findByClasseHorizontal(id,"");
    }
    
    public void findByClasseHorizontal(Entity entidade) throws AdsException {
        findByClasseHorizontal(entidade.valueOfId(),"");
    }
    
    public void findByClasseHorizontal(Entity entidade, String sqlAppend) throws AdsException {
        findByClasseHorizontal(entidade.valueOfId(),sqlAppend);
    }
    
    /**
     * Limpa os objetos normalizados da entidade
     */
    public void clearRelatedObjects() {
        eVazaoPermanente = null;
        eRazaoVertical = null;
        eRazaoHorizontal = null;
        eVazaoPrefixoSerie = null;
        eClasseVertical = null;
        eClasseHorizontal = null;
    }
    /**
     * Retorna os registros de ENSAIO_BANCADA que referenciam este registro através do atributo MODELO_HIDROMETRO_ID
     */
    public EntEnsaioBancada findAllEnsaioBancadaModeloHidrometro() throws AdsException {
        return findAllEnsaioBancadaModeloHidrometro("order by ID");
    }
    
    /**
     * Retorna os registros de ENSAIO_BANCADA que referenciam este registro através do atributo MODELO_HIDROMETRO_ID
     */
    public EntEnsaioBancada findAllEnsaioBancadaModeloHidrometro(String sqlAppend) throws AdsException {
        EntEnsaioBancada out = new EntEnsaioBancada(ctx);
        out.find("select ID from ENSAIO_BANCADA where MODELO_HIDROMETRO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de HIDROMETRO que referenciam este registro através do atributo MODELO_HIDROMETRO_ID
     */
    public EntHidrometro findAllHidrometroModeloHidrometro() throws AdsException {
        return findAllHidrometroModeloHidrometro("order by ID");
    }
    
    /**
     * Retorna os registros de HIDROMETRO que referenciam este registro através do atributo MODELO_HIDROMETRO_ID
     */
    public EntHidrometro findAllHidrometroModeloHidrometro(String sqlAppend) throws AdsException {
        EntHidrometro out = new EntHidrometro(ctx);
        out.find("select ID from HIDROMETRO where MODELO_HIDROMETRO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de MODELO_ENSAIO_INTRUMENTO que referenciam este registro através do atributo MODELO_HIDROMETRO_ID
     */
    public EntModeloEnsaioIntrumento findAllModeloEnsaioIntrumentoModeloHidrometro() throws AdsException {
        return findAllModeloEnsaioIntrumentoModeloHidrometro("order by ID");
    }
    
    /**
     * Retorna os registros de MODELO_ENSAIO_INTRUMENTO que referenciam este registro através do atributo MODELO_HIDROMETRO_ID
     */
    public EntModeloEnsaioIntrumento findAllModeloEnsaioIntrumentoModeloHidrometro(String sqlAppend) throws AdsException {
        EntModeloEnsaioIntrumento out = new EntModeloEnsaioIntrumento(ctx);
        out.find("select ID from MODELO_ENSAIO_INTRUMENTO where MODELO_HIDROMETRO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de SOLICITACAO_ENSAIO que referenciam este registro através do atributo MODELO_HIDROMETRO_ID
     */
    public EntSolicitacaoEnsaio findAllSolicitacaoEnsaioModeloHidrometro() throws AdsException {
        return findAllSolicitacaoEnsaioModeloHidrometro("order by ID");
    }
    
    /**
     * Retorna os registros de SOLICITACAO_ENSAIO que referenciam este registro através do atributo MODELO_HIDROMETRO_ID
     */
    public EntSolicitacaoEnsaio findAllSolicitacaoEnsaioModeloHidrometro(String sqlAppend) throws AdsException {
        EntSolicitacaoEnsaio out = new EntSolicitacaoEnsaio(ctx);
        out.find("select ID from SOLICITACAO_ENSAIO where MODELO_HIDROMETRO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oVazaoPermanenteId.setValue(aVazaoPermanenteId);
        oRazaoVerticalId.setValue(aRazaoVerticalId);
        oRazaoHorizontalId.setValue(aRazaoHorizontalId);
        oDescricaoDetalhada.setValue(aDescricaoDetalhada);
        oDescricao.setValue(aDescricao);
        oVazaoPrefixoSerieId.setValue(aVazaoPrefixoSerieId);
        oComprimento.setValue(aComprimento);
        oPortariaAprovacao.setValue(aPortariaAprovacao);
        oFatorK.setValue(aFatorK);
        oMarca.setValue(aMarca);
        oClasseVerticalId.setValue(aClasseVerticalId);
        oClasseHorizontalId.setValue(aClasseHorizontalId);
        oCodigo.setValue(aCodigo);
        oDiametroNominal.setValue(aDiametroNominal);
        oId.setValue(aId);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntModeloHidrometro.class);
            rule.setName("PK_MODHID");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntModeloHidrometro.class);
            rule.setAssociatedEntity(EntClasseModelo.class);
            rule.setName("FK_MODHID_CLASSE_HORIZONTAL");
            rule.addAttribute(new DomId("CLASSE_HORIZONTAL_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntModeloHidrometro.class);
            rule.setAssociatedEntity(EntClasseModelo.class);
            rule.setName("FK_MODHID_CLASSE_VERTICAL");
            rule.addAttribute(new DomId("CLASSE_VERTICAL_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntModeloHidrometro.class);
            rule.setAssociatedEntity(EntClasseModelo.class);
            rule.setName("FK_MODHID_RAZAO_HORIZONTAL");
            rule.addAttribute(new DomId("RAZAO_HORIZONTAL_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntModeloHidrometro.class);
            rule.setAssociatedEntity(EntClasseModelo.class);
            rule.setName("FK_MODHID_RAZAO_VERTICAL");
            rule.addAttribute(new DomId("RAZAO_VERTICAL_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntModeloHidrometro.class);
            rule.setAssociatedEntity(EntVazaoPrefixoSerie.class);
            rule.setName("FK_MODHID_VAZAO_HIDROMETRO");
            rule.addAttribute(new DomId("VAZAO_PREFIXO_SERIE_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntModeloHidrometro.class);
            rule.setAssociatedEntity(EntVazaoPrefixoSerie.class);
            rule.setName("FK_MODHID_VAZAO_PERMANENTE");
            rule.addAttribute(new DomId("VAZAO_PERMANENTE_ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntModeloHidrometro.class);
            rule.setName("UK_MODHID_COD_DIAM_VAZAO");
            rule.addAttribute(new DomUpper("CODIGO",""));
            rule.addAttribute(new DomInteger("DIAMETRO_NOMINAL",""));
            rule.addAttribute(new DomId("VAZAO_PREFIXO_SERIE_ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntModeloHidrometro.class);
            rule.setName("UK_MODHID_NOME");
            rule.addAttribute(new DomText("DESCRICAO",""));
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    protected void preInsert() throws AdsException {
        checkRule(isPrefixosIguaisVazoesInformadasValid(), "PREFIXOS_IGUAIS_VAZOES_INFORMADAS", "Prefixos das vazões informadas devem ser iguais!");
        checkRule(isVerificarClassesVerticalHorizontalValid(), "VERIFICAR_CLASSES_VERTICAL_HORIZONTAL", "O modelo deve ter classes vertical ou horizontal (ou ambas) registradas!");
    }
    
    @Override
    protected void preUpdate() throws AdsException {
        checkRule(isPrefixosIguaisVazoesInformadasValid(), "PREFIXOS_IGUAIS_VAZOES_INFORMADAS", "Prefixos das vazões informadas devem ser iguais!");
        checkRule(isVerificarClassesVerticalHorizontalValid(), "VERIFICAR_CLASSES_VERTICAL_HORIZONTAL", "O modelo deve ter classes vertical ou horizontal (ou ambas) registradas!");
    }
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
        if (getMarca().isNull()) {
            setMarca(getMarca().getDefaultValue());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
    
    /**
     * Atribuir código do modelo.
     */
    public void atribuirCodigoModelo(DomDouble vazaoNominal) throws AdsException {
        // <user-code id="21096803" parentId="21096778" hashcode="-434008e9" length="161">
        /*
        setCodigo(findTipoModeloHidrometro().valueOfPrefixoModelo()
                  + " " + vazaoNominal.toText()
                  + " " + getDiametroNominal().toText());
        */
        
        // </user-code>
    }
    
    /**
     * Regra de validação: O modelo deve ter classes vertical ou horizontal (ou ambas) registradas!
     */
    private Object isVerificarClassesVerticalHorizontalValid() throws AdsException {
        // <user-code id="20275662" parentId="20275624" hashcode="-4c577f3e" length="140">
        // Se classes não informadas, retornar erro de validação.	
        return !(getClasseHorizontalId().isNull() && getClasseVerticalId().isNull()); 
        
        // </user-code>
    }
    
    /**
     * Regra de validação: Prefixos das vazões informadas devem ser iguais!
     */
    private Object isPrefixosIguaisVazoesInformadasValid() throws AdsException {
        // <user-code id="22250490" parentId="22250485" hashcode="78feb566" length="119">
        return (findVazaoPrefixoSerie().valueOfPrefixoNumeroSerie().equals(findVazaoPermanente().valueOfPrefixoNumeroSerie()));
        // </user-code>
    }
}
